package org.springframework.orm.hibernate4.support;
 
import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
 
import org.springframework.dao.DataAccessResourceFailureException;
import org.springframework.orm.hibernate4.SessionFactoryUtils;
import org.springframework.orm.hibernate4.SessionHolder;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import org.springframework.web.filter.OncePerRequestFilter;
 
/**
 * Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire
 * processing of the request. Intended for the "Open Session in View" pattern,
 * i.e. to allow for lazy loading in web views despite the original transactions
 * already being completed.
 *
 * <p>This filter makes Hibernate Sessions available via the current thread, which
 * will be autodetected by transaction managers. It is suitable for service layer
 * transactions via {@link org.springframework.orm.hibernate4.HibernateTransactionManager}
 * as well as for non-transactional execution (if configured appropriately).
 *
 * <p><b>NOTE</b>: This filter will by default <i>not</i> flush the Hibernate Session,
 * with the flush mode set to <code>FlushMode.NEVER</code>. It assumes to be used
 * in combination with service layer transactions that care for the flushing: The
 * active transaction manager will temporarily change the flush mode to
 * <code>FlushMode.AUTO</code> during a read-write transaction, with the flush
 * mode reset to <code>FlushMode.NEVER</code> at the end of each transaction.
 *
 * <p><b>WARNING:</b> Applying this filter to existing logic can cause issues that
 * have not appeared before, through the use of a single Hibernate Session for the
 * processing of an entire request. In particular, the reassociation of persistent
 * objects with a Hibernate Session has to occur at the very beginning of request
 * processing, to avoid clashes with already loaded instances of the same objects.
 *
 * <p>Looks up the SessionFactory in Spring's root web application context.
 * Supports a "sessionFactoryBeanName" filter init-param in <code>web.xml</code>;
 * the default bean name is "sessionFactory". Looks up the SessionFactory on each
 * request, to avoid initialization order issues (when using ContextLoaderServlet,
 * the root application context will get initialized <i>after</i> this filter).
 *
 * @author Juergen Hoeller
 * @since 3.1
 * @see #lookupSessionFactory
 * @see OpenSessionInViewInterceptor
 * @see org.springframework.orm.hibernate4.HibernateTransactionManager
 * @see org.springframework.transaction.support.TransactionSynchronizationManager
 */
public class OpenSessionInViewFilter extends OncePerRequestFilter {
 
        public static final String DEFAULT_SESSION_FACTORY_BEAN_NAME = "sessionFactory";
 
        private String sessionFactoryBeanName = DEFAULT_SESSION_FACTORY_BEAN_NAME;
 
 
        /**
         * Set the bean name of the SessionFactory to fetch from Spring's
         * root application context. Default is "sessionFactory".
         * @see #DEFAULT_SESSION_FACTORY_BEAN_NAME
         */
        public void setSessionFactoryBeanName(String sessionFactoryBeanName) {
                this.sessionFactoryBeanName = sessionFactoryBeanName;
        }
 
        /**
         * Return the bean name of the SessionFactory to fetch from Spring's
         * root application context.
         */
        protected String getSessionFactoryBeanName() {
                return this.sessionFactoryBeanName;
        }
 
 
        @Override
        protected void doFilterInternal(
                        HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
                        throws ServletException, IOException {
 
                SessionFactory sessionFactory = lookupSessionFactory(request);
                boolean participate = false;
 
                if (TransactionSynchronizationManager.hasResource(sessionFactory)) {
                        // Do not modify the Session: just set the participate flag.
                        participate = true;
                }
                else {
                        logger.debug("Opening Hibernate Session in OpenSessionInViewFilter");
                        Session session = openSession(sessionFactory);
                        TransactionSynchronizationManager.bindResource(sessionFactory, new SessionHolder(session));
                }
 
                try {
                        filterChain.doFilter(request, response);
                }
 
                finally {
                        if (!participate) {
                                SessionHolder sessionHolder =
                                                (SessionHolder) TransactionSynchronizationManager.unbindResource(sessionFactory);
                                logger.debug("Closing Hibernate Session in OpenSessionInViewFilter");
                                SessionFactoryUtils.closeSession(sessionHolder.getSession());
                        }
                }
        }
 
        /**
         * Look up the SessionFactory that this filter should use,
         * taking the current HTTP request as argument.
         * <p>The default implementation delegates to the {@link #lookupSessionFactory()}
         * variant without arguments.
         * @param request the current request
         * @return the SessionFactory to use
         */
        protected SessionFactory lookupSessionFactory(HttpServletRequest request) {
                return lookupSessionFactory();
        }
 
        /**
         * Look up the SessionFactory that this filter should use.
         * <p>The default implementation looks for a bean with the specified name
         * in Spring's root application context.
         * @return the SessionFactory to use
         * @see #getSessionFactoryBeanName
         */
        protected SessionFactory lookupSessionFactory() {
                if (logger.isDebugEnabled()) {
                        logger.debug("Using SessionFactory '" + getSessionFactoryBeanName() + "' for OpenSessionInViewFilter");
                }
                WebApplicationContext wac = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
                return wac.getBean(getSessionFactoryBeanName(), SessionFactory.class);
        }
 
        /**
         * Open a Session for the SessionFactory that this filter uses.
         * <p>The default implementation delegates to the
         * <code>SessionFactory.openSession</code> method and
         * sets the <code>Session</code>'s flush mode to "MANUAL".
         * @param sessionFactory the SessionFactory that this filter uses
         * @return the Session to use
         * @throws DataAccessResourceFailureException if the Session could not be created
         * @see org.hibernate.FlushMode#MANUAL
         */
        protected Session openSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
                try {
                        Session session = SessionFactoryUtils.openSession(sessionFactory);
                        session.setFlushMode(FlushMode.MANUAL);
                        return session;
                }
                catch (HibernateException ex) {
                        throw new DataAccessResourceFailureException("Could not open Hibernate Session", ex);
                }
        }
 
}